home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 051-075 / disk_055 / vt100 / script.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  16KB  |  727 lines
  1. /*************************************************************
  2.  * vt100 terminal emulator - Script file support
  3.  *
  4.  *    v2.6 870227 DBW - bug fixes for all the stuff in v2.5
  5.  *    v2.5 870214 DBW - more additions (see readme file)
  6.  *    v2.4 861214 DBW - lots of fixes/additions (see readme file)
  7.  *    v2.3 861101 DBW - minor bug fixes
  8.  *    v2.2 861012 DBW - more of the same
  9.  *    v2.1 860915 DBW - new features (see README)
  10.  *         860901 ACS - Added BAUD, PARITY and WORD commands & handling
  11.  *         860823 DBW - Integrated and rewrote lots of code
  12.  *         860815 Steve Drew: Initial version written of SCRIPT.C
  13.  *    v2.0 860809 DBW - Major rewrite
  14.  *    v1.1 860720 DBW    - Switches, 80 cols, colors, bug fixes
  15.  *    v1.0 860712 DBW    - First version released
  16.  *
  17.  *************************************************************/
  18.  
  19. #include "vt100.h"
  20.  
  21. struct COMMAND {
  22.     void (*func)();
  23.     char *cname;
  24.     };
  25.  
  26. struct LABEL  {
  27.     struct LABEL *next;
  28.     char *name;
  29.     long pos;
  30.     };
  31.  
  32. extern long atol();
  33.  
  34. /****************  globals  needed  ******************/
  35.  
  36. char        on_string[20];       /* string to match on for on cmd    */
  37. char         wait_string[20];     /* string to match of for wait cmd  */
  38. char         golabel[20];         /* label we are looking for in goto */
  39. char         on_cmd[20];          /* command to execute when on matchs*/
  40. int         onsize;             /* size of on_string                */
  41. int         waitsize;            /* size of wait_string              */
  42. int         onpos;               /* position in on string for search */
  43. int         waitpos;             /* pos in wait_string for search    */
  44. int         on_match;            /* flag set while doing on_cmd      */
  45. FILE         *sf;                 /* file pointer for script file     */
  46. struct LABEL     *lbase = NULL;       /* will point to first label     */
  47. struct LABEL     *labels;             /* current label pointer         */
  48.  
  49. /********************** command tables *******************************/
  50. static struct COMMAND inicmds[] = {    /* initialization commands */
  51.     cmd_bkg,    "bac",        /* set background color        */
  52.     cmd_bold,    "bol",        /* set bold color         */
  53.     cmd_buf,    "buf",        /* set buffer size         */
  54.     cmd_cursor,    "cur",        /* set cursor color        */
  55.     cmd_depth,    "dep",        /* set screen depth         */
  56.     cmd_fore,    "for",        /* set foreground color        */
  57.     cmd_inter,    "int",        /* interlace ON/OFF        */
  58.     cmd_lines,    "lin",        /* num lines             */
  59.     cmd_screen,    "scr",        /* Screen WB/CUST         */
  60.     cmd_volume,    "vol",        /* set volume            */
  61.     cmd_wb,    "wb",        /* use WB colors        */
  62.     cmd_null,   NULL        /* mark the end of the list */
  63.     };
  64. static struct COMMAND scrcmds[] = {    /* script only commands */
  65.     cmd_as,     "asc",        /* ascii send               */
  66.     cmd_beep,    "bee",        /* Beep                */
  67.     cmd_cap,    "cap",        /* ascii capture on/off     */
  68.     cmd_cd,     "cd",        /* change directory        */
  69.     cmd_delay,  "del",        /* delay amount of seconds  */
  70.     cmd_goto,   "got",        /* goto label               */
  71.     cmd_kb,    "kb",        /* kermit bye (for server)  */
  72.     cmd_kg,     "kg",           /* kermit get file          */
  73.     cmd_kr,     "kr",           /* kermit receive file      */
  74.     cmd_ks,     "ks",           /* kermit send file         */
  75.     cmd_on,     "on",         /* on a 'string' do a cmd   */
  76.     cmd_sb,     "sb",        /* Send a break            */
  77.     cmd_send,   "send",         /* send string to host      */
  78.     cmd_wait,   "wait",         /* wait for a host string   */
  79.     cmd_xr,     "xr",           /* xmodem receive file      */
  80.     cmd_xs,     "xs",           /* xmodem send file         */
  81.     cmd_null,   NULL        /* mark the end of the list */
  82.     };
  83. static struct COMMAND commands[]= {    /* generally available commands */
  84.     cmd_appcur,    "app",        /* turn app. cursor on/off  */
  85.     cmd_baud,   "bau",        /* Set Baud Rate            */
  86.     cmd_bt,     "bre",        /* Set Break Time        */
  87.     cmd_conv,    "con",        /* convert bs to del        */
  88.     cmd_echo,    "ech",        /* turn echo on or off        */
  89.     cmd_exit,   "exi",        /* exit script file         */
  90.     cmd_fnc,    "f",        /* define function key        */
  91.     cmd_key,    "key",        /* keyscript character        */
  92.     cmd_mode,    "mod",        /* KERMIT transfer mode        */
  93.     cmd_numkey,    "numkey",    /* turn numeric kpad on/off */
  94.     cmd_parity, "parity",    /* Set Parity            */
  95.     cmd_swap,    "swap",        /* Swap BS and DEL        */
  96.     cmd_wrap,    "wrap",        /* turn wrap on or off        */
  97.     cmd_null,   NULL        /* mark the end of the list */
  98.     };
  99.  
  100. /********************************************************************/
  101. /* checks char to see if match with on string or wait_string        */
  102. /* if on string match oncmd gets executed imediately,               */
  103. /* if wait_string match script_wait is set.                         */
  104. /********************************************************************/
  105.  
  106. chk_script(c)
  107. char c;
  108.     {
  109.     if (on_string[0] != '\0') {
  110.         if (on_string[onpos] == c) {
  111.             onpos++;
  112.             if (onpos == onsize) {
  113.                 on_match = TRUE;
  114.                 do_script_cmd(ONCOMMAND); 
  115.                 on_match = FALSE;
  116.                 return(0);
  117.         }
  118.         }
  119.         else onpos = 0;
  120.     }
  121.     if (wait_string[0] != '\0') {
  122.        if (wait_string[waitpos] != c) {
  123.             waitpos = 0;
  124.             return(0);
  125.         }
  126.         waitpos++;
  127.         if (waitpos != waitsize) return(0);
  128.         wait_string[0] = '\0';
  129.         script_wait = FALSE;
  130.     }
  131.     }
  132.  
  133. script_start(file)
  134. char *file;
  135.     {
  136.     if (strlen(file) == 0 || *file == '#') return(0);
  137.     if ((sf = fopen(file, "r")) == NULL) {
  138.         req("Can't open script file",file,0);
  139.         return(0);
  140.     }
  141.     script_on = TRUE;
  142.     script_wait = FALSE;
  143.     wait_string[0] = '\0';
  144.     on_string[0] = '\0';
  145.     on_match = FALSE;
  146.     lbase = NULL;
  147.     }
  148.  
  149. /* return pointer to next word. set l to size of the word */
  150.  
  151. char *next_wrd(s,l)
  152. char *s;
  153. int *l;
  154.     {
  155.     char *p;
  156.  
  157.     while(*s && (*s == ' ' || *s == '\t')) s++;
  158.     p = s;
  159.     while(*s && (*s != ' ' && *s != '\t')) s++;
  160.     *l = s-p;
  161.     return(p);
  162.     }
  163.  
  164. exe_cmd(p,l)
  165. char *p;
  166. int l;
  167.     {
  168.     register int i,l2;
  169.  
  170.     /* downcase the command */
  171.     for (i=0; i<l; i++) p[i] |= ' ';
  172.  
  173.     /* now search for it (first in the init command list) */
  174.     if (doing_init)
  175.     for (i=0; inicmds[i].func != cmd_null; ++i) {
  176.         l2 = strlen(inicmds[i].cname);
  177.         if (l >= l2 && strncmp(p, inicmds[i].cname, l2) == 0) {
  178.         (*inicmds[i].func)(next_wrd(p+l, &l));
  179.         return(TRUE);
  180.         }
  181.         }
  182.  
  183.     /* or the script command list */
  184.     else
  185.     for (i=0; scrcmds[i].func != cmd_null; ++i) {
  186.         l2 = strlen(scrcmds[i].cname);
  187.         if (l >= l2 && strncmp(p, scrcmds[i].cname, l2) == 0) {
  188.         (*scrcmds[i].func)(next_wrd(p+l, &l));
  189.         return(TRUE);
  190.         }
  191.         }
  192.  
  193.     /* now search for it (in the standard command list) */
  194.     for (i=0; commands[i].func != cmd_null; ++i) {
  195.     l2 = strlen(commands[i].cname);
  196.         if (l >= l2 && strncmp(p, commands[i].cname, l2) == 0) {
  197.             (*commands[i].func)(next_wrd(p+l, &l));
  198.             return(TRUE);
  199.         }
  200.     }
  201.     if (doing_init) {
  202.     puts("INIT - unknown command:");
  203.     puts(p);
  204.     }
  205.     else req("Script - unknown command:",p,0);
  206.  
  207.     return(FALSE);
  208.     }
  209.  
  210. struct LABEL *find_label(lname)
  211. char *lname;
  212.     {
  213.     struct LABEL *label;
  214.   
  215.     label = lbase;
  216.     while(label != NULL) {
  217.     if (strcmp(label->name, lname) == 0) return (label);
  218.     label = label->next;
  219.     }
  220.     return(NULL);
  221.     }
  222.  
  223. do_script_cmd(stat)
  224. int stat;
  225.     {
  226.     int len,l;
  227.     char line[256];
  228.     char *p;
  229.  
  230.     /* if ON command is matched and we were     */
  231.     /* doing a DELAY then abort the delay timer,*/
  232.     /* except if on_cmd was just a SEND.        */
  233.     if (stat == ONCOMMAND) {
  234.         strcpy(line,on_cmd);
  235.         p = next_wrd(line,&l);
  236.     if (*p != 'S' && script_wait == WAIT_TIMER)  {
  237.             AbortIO((char *) &Script_Timer);
  238.             Wait (1L << Script_Timer_Port->mp_SigBit);
  239.  
  240.         /* script will proceed after on command    */
  241.             script_wait = FALSE;
  242.         }
  243.     exe_cmd(p,l);
  244.         return(0);
  245.     }
  246.     script_wait = FALSE;
  247.     while(fgets(line,256,sf) != NULL) {
  248.        len = strlen(line);
  249.        line[--len] = '\0';
  250.        p = next_wrd(&line[0], &l);
  251.        if (*(p + l - 1) == ':') {           /* its a label */
  252.            *(p + l - 1) = '\0';
  253.            if (find_label(p) == NULL) {       /* it's a new label */
  254.         if (lbase == NULL)  {          /* it's the first label */
  255.             labels = lbase = (struct LABEL *) 
  256.             malloc(sizeof (struct LABEL));
  257.             }
  258.         else {
  259.             labels->next = (struct LABEL *)
  260.             malloc(sizeof (struct LABEL));
  261.             labels = labels->next;
  262.             }
  263.         labels->pos  = ftell(sf);
  264.         labels->name = malloc(l);
  265.         labels->next = NULL;
  266.         strcpy(labels->name, p);
  267.         if (stat == GOTOLABEL && strcmp(p, golabel) == 0) 
  268.                       stat = NEXTCOMMAND;
  269.         }
  270.         p = next_wrd(p+l+1, &l);
  271.         }     /* end of it's a label */
  272.     if (stat == GOTOLABEL || *p == '#') continue;
  273.     if (*p) exe_cmd(p,l);
  274.     return(0);
  275.     }         /* end of while */
  276.     if (stat == GOTOLABEL) req("Script - label not found: ",golabel,0);
  277.     exit_script();
  278.     }
  279.  
  280. exit_script()
  281.     {
  282.     if (script_wait == WAIT_TIMER)      /* timer not done yet */
  283.        AbortIO((char *) &Script_Timer); /* so abort it */
  284.     req("Script - terminated","",0);    
  285.     script_on = FALSE;
  286.     script_wait = TRUE;
  287.     fclose(sf);
  288.     }
  289.  
  290. /* remove quotes terminate string & return pointer to start */
  291.  
  292. char *tostring(ptr)
  293. char *ptr;
  294.     {
  295.     char *s1,*s2;
  296.  
  297.     s1 = ptr;
  298.     if (*ptr == '"') {
  299.         while(*ptr++  && *ptr != '"') ;
  300.         if (*ptr == '"') {
  301.             *ptr = '\0';  
  302.             ptr = s2 = ++s1;
  303.             while(*s2) {
  304.         if    (*s2 != '^')     *s1++ = *s2;
  305.         else if (*(s2+1) == '^') *s1++ = *s2++;
  306.         else             *s1++ = ((*++s2)|' ')-96;
  307.         s2++;
  308.         }
  309.         *s1 = '\0';
  310.             return(ptr);
  311.         }
  312.     }
  313.     if (*s1 == '^') {
  314.         *s1 = (*(s1+1)|' ')-96;
  315.         *(s1+1) = '\0';
  316.         return(s1);
  317.         }
  318.     *(s1+1) = '\0';
  319.     return(s1);
  320.     }   
  321.  
  322. /***************************** SCRIPT COMMANDS ********************/
  323.  
  324. void cmd_goto(lname)
  325. char *lname;
  326.     {
  327.     struct LABEL *label;
  328.                            /* if on_cmd was a goto kill wait state */
  329.     if (on_match) { wait_string[0] = '\0'; script_wait = FALSE; }
  330.     if ((label = find_label(lname)) == NULL) {  /* is it forward */
  331.         strcpy(golabel,lname);
  332.         do_script_cmd(GOTOLABEL);
  333.     }
  334.     else {
  335.         fseek(sf,(long)(label->pos),0);
  336.     }
  337.     }
  338.  
  339. void cmd_send(str)
  340. char *str;
  341.     {
  342.     sendstring(tostring(str));
  343.     }
  344.  
  345. void cmd_wait(str)
  346. char *str;
  347.     {
  348.     str = tostring(str);
  349.     *(str+20) = '\0';         /* 20 characters max */
  350.     strcpy(wait_string, str);
  351.     waitsize = strlen(str);
  352.     script_wait = WAIT_STRING;
  353.     }
  354.  
  355. void cmd_on(str)
  356. char *str;
  357.     {
  358.    char *p;
  359.  
  360.     p = tostring(str);
  361.     strcpy(on_string, p);
  362.     onsize = strlen(p);
  363.     *(p+onsize+2+20) = '\0';        /* 20 characters max */
  364.     strcpy(on_cmd,p+onsize+2);
  365.     }
  366.  
  367. void cmd_delay(seconds)
  368. char *seconds;
  369.     {
  370.     script_wait = WAIT_TIMER;
  371.     Script_Timer.tr_time.tv_secs = atoi(seconds);
  372.     Script_Timer.tr_time.tv_micro = 0;
  373.     SendIO((char *) &Script_Timer.tr_node);
  374.     }
  375.  
  376. void cmd_exit(option)
  377. char *option;
  378.     {
  379.     char *p;
  380.     int  l;
  381.  
  382.     if (doing_init) return;
  383.  
  384.     if (*option) {
  385.     p = next_wrd(option,&l);
  386.     *(p+l) = '\000';
  387.     if  (strcmp(p,"vt100") == 0 || strcmp(p,"VT100") == 0)
  388.         cleanup("Exit vt100 from script",0);
  389.     exit_script();
  390.     script_start(p);
  391.     }
  392.     else exit_script();
  393.     }
  394.  
  395. void cmd_ks(file)
  396. char *file;
  397.     {
  398.     multi_xfer(file, doksend, 1);
  399.     }
  400.  
  401. void cmd_kr(file)
  402. char *file;
  403.     {
  404.     multi_xfer(file, dokreceive, 0);
  405.     }
  406.  
  407. void cmd_kg(file)
  408. char *file;
  409.     {
  410.     server = TRUE;
  411.     multi_xfer(file, dokreceive, 0);
  412.     }
  413.  
  414. void cmd_kb()
  415.     {
  416.     saybye();
  417.     }
  418.  
  419. void cmd_xs(file)
  420. char *file;
  421.     {
  422.     multi_xfer(file, XMODEM_Send_File, 1);
  423.     }
  424.  
  425. void cmd_xr(file)
  426. char *file;
  427.     {
  428.     multi_xfer(file, XMODEM_Read_File, 1);
  429.     }
  430.  
  431. void cmd_cap(file)
  432. char *file;
  433.     {
  434.     do_capture(file);
  435.     }
  436.  
  437. void cmd_as(file)
  438. char *file;
  439.     {
  440.     do_send(file);
  441.     }
  442.  
  443. void cmd_cd(name)
  444. char *name;
  445.     {
  446.     set_dir(name);
  447.     }
  448.  
  449. void cmd_sb(str)
  450. char *str;
  451.     {
  452.     sendbreak();
  453.     }
  454.  
  455. void cmd_baud(rate)
  456. char *rate;
  457.     {
  458.     int i = atoi(rate);
  459.  
  460.     switch( i )
  461.     {
  462.     case  300:
  463.     case 1200:
  464.     case 2400:
  465.     case 4800:
  466.     case 9600:
  467.     if (doing_init) p_baud = i;
  468.     else            setserbaud(i, TRUE);
  469.     break;
  470.  
  471.     default:
  472.     if (doing_init) {
  473.         puts("INIT - invalid baud rate:");
  474.         puts(rate);
  475.         }
  476.     else req("Script - invalid baud rate: ",rate,0);
  477.     break;
  478.     }
  479.     }
  480.  
  481. void cmd_parity(par)
  482. char *par;
  483.     {
  484.     int i;
  485.  
  486.     switch( *par|' ' )
  487.     {
  488.     case 'n': i =  0; break;
  489.     case 'm': i =  1; break;
  490.     case 's': i =  2; break;
  491.     case 'e': i =  3; break;
  492.     case 'o': i =  4; break;
  493.  
  494.     default:
  495.     if (doing_init) {
  496.         puts("INIT - invalid parity:");
  497.         puts(par);
  498.         }
  499.     else req("Script - invalid parity: ",par,0);
  500.     return;
  501.     }
  502.     p_parity = i;
  503.     if (doing_init) return;
  504.  
  505.     ClearMenuStrip( mywindow );         /* Remove old menu */
  506.     InitCommItems();                    /* Re-do comm menu   */
  507.     SetMenuStrip(mywindow,&menu[0]);    /* Re-display the menu */    
  508.     }
  509.  
  510. void cmd_bt(breaklength)
  511. char *breaklength;
  512.     {
  513.     p_break = atol(breaklength);
  514.     if (doing_init) return;
  515.  
  516.     AbortIO(Read_Request);
  517.     Read_Request->io_BrkTime = Write_Request->io_BrkTime = p_break;
  518.     setparams();
  519.     }
  520.  
  521. void cmd_mode(tmode)
  522. char *tmode;
  523.     {
  524.     switch (*tmode|' ') {
  525.     case 'i':
  526.     p_mode = 0;
  527.     break;
  528.  
  529.     case 'c':
  530.     p_mode = 1;
  531.     break;
  532.  
  533.     default:
  534.     if (doing_init) {
  535.         puts("INIT - invalid transfer mode: ");
  536.         puts(tmode);
  537.         }
  538.     else req("Script - invalid transfer mode: ",tmode,0);
  539.     return;
  540.     }
  541.     if (doing_init) return;
  542.  
  543.     ClearMenuStrip(mywindow);
  544.     InitCommItems();                    /* Re-do comm menu   */
  545.     SetMenuStrip(mywindow,&menu[0]);
  546.     }
  547.  
  548. void cmd_beep(dummy)
  549. char    *dummy;
  550.     {
  551.     if (p_volume == 0) DisplayBeep(NULL);
  552.     else {
  553.     BeginIO(&Audio_Request);
  554.     WaitIO(&Audio_Request);
  555.     }
  556.     }
  557.  
  558. void setvar(par,typ,var)
  559. char    *par;
  560. int    typ,*var;
  561.     {
  562.     int    i;
  563.  
  564.     switch (typ) {
  565.     case 0: /* ON/OFF or YES/NO */
  566.     case 1: /* not case */
  567.     if ((par[1]|' ') == 'n' || (par[0]|' ') == 'y') *var = 1-typ;
  568.     else                        *var = typ;
  569.     break;
  570.  
  571.     case 2: /* read hex number */
  572.     if (sscanf(par,"%x",&i) == 1) *var = i;
  573.         
  574.     break;
  575.  
  576.     case 3: /* read decimal number */
  577.     if (sscanf(par,"%d",&i) == 1) *var = i;
  578.     break;
  579.     }
  580.     }
  581.  
  582. void cmd_echo(par)
  583. char    *par;
  584.     {
  585.     setvar(par,0,&p_echo);
  586.     if (doing_init == 0) redoutil();
  587.     }
  588.  
  589. void cmd_wrap(par)
  590. char    *par;
  591.     {
  592.     setvar(par,0,&p_wrap);
  593.     if (doing_init == 0) redoutil();
  594.     }
  595.  
  596. void cmd_numkey(par)
  597. char    *par;
  598.     {
  599.     setvar(par,1,&p_keyapp);
  600.     if (doing_init == 0) redoutil();
  601.     }
  602.  
  603. void cmd_appcur(par)
  604. char    *par;
  605.     {
  606.     setvar(par,0,&p_curapp);
  607.     if (doing_init == 0) redoutil();
  608.     }
  609.  
  610. void cmd_swap(par)
  611. char    *par;
  612.     {
  613.     setvar(par,0,&p_bs_del);
  614.     if (doing_init == 0) redoutil();
  615.     }
  616.  
  617. void cmd_bkg(par)
  618. char    *par;
  619.     {
  620.     setvar(par,2,&p_background);
  621.     }
  622.  
  623. void cmd_bold(par)
  624. char    *par;
  625.     {
  626.     setvar(par,2,&p_bold);
  627.     }
  628.  
  629. void cmd_buf(par)
  630. char    *par;
  631.     {
  632.     setvar(par,3,&p_buffer);
  633.     }
  634.  
  635. void cmd_cursor(par)
  636. char    *par;
  637.     {
  638.     setvar(par,2,&p_cursor);
  639.     }
  640.  
  641. void cmd_depth(par)
  642. char    *par;
  643.     {
  644.     setvar(par,3,&p_depth);
  645.     }
  646.  
  647. void cmd_fore(par)
  648. char    *par;
  649.     {
  650.     setvar(par,2,&p_foreground);
  651.     }
  652.  
  653. void cmd_inter(par)
  654. char    *par;
  655.     {
  656.     setvar(par,0,&p_interlace);
  657.     }
  658.  
  659. void cmd_lines(par)
  660. char    *par;
  661.     {
  662.     setvar(par,3,&p_lines);
  663.     }
  664.  
  665. void cmd_screen(par)
  666. char    *par;
  667.     {
  668.     if ((par[0]|' ') == 'w') p_screen = 0;
  669.     else             p_screen = 1;
  670.     }
  671.  
  672. void cmd_wb(par)
  673. char    *par;
  674.     {
  675.     setvar(par,0,&p_wbcolors);
  676.     }
  677.  
  678. void cmd_key(par)
  679. char    *par;
  680.     {
  681.     int    i;
  682.  
  683.     if (sscanf(par,"%x",&i) == 1) p_keyscript = (char)(i & 0x7f);
  684.     }
  685.  
  686. void cmd_volume(par)
  687. char    *par;
  688.     {
  689.     setvar(par,3,&p_volume);
  690.     }
  691.  
  692. void cmd_conv(par)
  693. char    *par;
  694.     {
  695.     setvar(par,0,&p_bs_del);
  696.     if (doing_init == 0) redoutil();
  697.     }
  698.  
  699. void cmd_fnc(par)
  700. char    *par;
  701.     {
  702.     char    *s;
  703.     int        l;
  704.     int        i = atoi(par);
  705.  
  706.     s = par;
  707.     if (*s) s = next_wrd(s,&l);        /* skip key number */
  708.     if (*s) s = next_wrd(s+l+1,&l);    /* point at desired string */
  709.     if (*s) s = tostring(s);        /* convert the string */
  710.     if (*s && i > 0 && i < 21) {
  711.     if (i > 10) {
  712.         p_F[i-11] = malloc(strlen(s)+1);
  713.         strcpy(p_F[i-11],s);
  714.         }
  715.     else {
  716.         p_f[i-1] = malloc(strlen(s)+1);
  717.         strcpy(p_f[i-1],s);
  718.         }
  719.     }
  720.     }
  721.  
  722. void cmd_null(dummy)
  723. char *dummy;
  724.     {
  725.     }
  726.  
  727.